//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS WorkSpacesWeb service.
///
/// Amazon WorkSpaces Secure Browser is a low cost, fully managed WorkSpace built specifically to facilitate secure, web-based workloads. WorkSpaces Secure Browser makes it easy for customers to safely provide their employees with access to internal websites and SaaS web applications without the administrative burden of appliances or specialized client software. WorkSpaces Secure Browser provides simple policy tools tailored for user interactions, while offloading common tasks like capacity management, scaling, and maintaining browser images.
public struct WorkSpacesWeb: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the WorkSpacesWeb client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "WorkSpacesWeb",
            serviceIdentifier: "workspaces-web",
            serviceProtocol: .restjson,
            apiVersion: "2020-07-08",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: WorkSpacesWebErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "us-east-1": "workspaces-web-fips.us-east-1.amazonaws.com",
            "us-west-2": "workspaces-web-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Associates a browser settings resource with a web portal.
    @Sendable
    @inlinable
    public func associateBrowserSettings(_ input: AssociateBrowserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateBrowserSettingsResponse {
        try await self.client.execute(
            operation: "AssociateBrowserSettings", 
            path: "/portals/{portalArn+}/browserSettings", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a browser settings resource with a web portal.
    ///
    /// Parameters:
    ///   - browserSettingsArn: The ARN of the browser settings.
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateBrowserSettings(
        browserSettingsArn: String,
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateBrowserSettingsResponse {
        let input = AssociateBrowserSettingsRequest(
            browserSettingsArn: browserSettingsArn, 
            portalArn: portalArn
        )
        return try await self.associateBrowserSettings(input, logger: logger)
    }

    /// Associates a data protection settings resource with a web portal.
    @Sendable
    @inlinable
    public func associateDataProtectionSettings(_ input: AssociateDataProtectionSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateDataProtectionSettingsResponse {
        try await self.client.execute(
            operation: "AssociateDataProtectionSettings", 
            path: "/portals/{portalArn+}/dataProtectionSettings", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a data protection settings resource with a web portal.
    ///
    /// Parameters:
    ///   - dataProtectionSettingsArn: The ARN of the data protection settings.
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateDataProtectionSettings(
        dataProtectionSettingsArn: String,
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateDataProtectionSettingsResponse {
        let input = AssociateDataProtectionSettingsRequest(
            dataProtectionSettingsArn: dataProtectionSettingsArn, 
            portalArn: portalArn
        )
        return try await self.associateDataProtectionSettings(input, logger: logger)
    }

    /// Associates an IP access settings resource with a web portal.
    @Sendable
    @inlinable
    public func associateIpAccessSettings(_ input: AssociateIpAccessSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateIpAccessSettingsResponse {
        try await self.client.execute(
            operation: "AssociateIpAccessSettings", 
            path: "/portals/{portalArn+}/ipAccessSettings", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates an IP access settings resource with a web portal.
    ///
    /// Parameters:
    ///   - ipAccessSettingsArn: The ARN of the IP access settings.
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateIpAccessSettings(
        ipAccessSettingsArn: String,
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateIpAccessSettingsResponse {
        let input = AssociateIpAccessSettingsRequest(
            ipAccessSettingsArn: ipAccessSettingsArn, 
            portalArn: portalArn
        )
        return try await self.associateIpAccessSettings(input, logger: logger)
    }

    /// Associates a network settings resource with a web portal.
    @Sendable
    @inlinable
    public func associateNetworkSettings(_ input: AssociateNetworkSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateNetworkSettingsResponse {
        try await self.client.execute(
            operation: "AssociateNetworkSettings", 
            path: "/portals/{portalArn+}/networkSettings", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a network settings resource with a web portal.
    ///
    /// Parameters:
    ///   - networkSettingsArn: The ARN of the network settings.
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateNetworkSettings(
        networkSettingsArn: String,
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateNetworkSettingsResponse {
        let input = AssociateNetworkSettingsRequest(
            networkSettingsArn: networkSettingsArn, 
            portalArn: portalArn
        )
        return try await self.associateNetworkSettings(input, logger: logger)
    }

    /// Associates a session logger with a portal.
    @Sendable
    @inlinable
    public func associateSessionLogger(_ input: AssociateSessionLoggerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateSessionLoggerResponse {
        try await self.client.execute(
            operation: "AssociateSessionLogger", 
            path: "/portals/{portalArn+}/sessionLogger", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a session logger with a portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the portal to associate to the session logger ARN.
    ///   - sessionLoggerArn: The ARN of the session logger to associate to the portal ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateSessionLogger(
        portalArn: String,
        sessionLoggerArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateSessionLoggerResponse {
        let input = AssociateSessionLoggerRequest(
            portalArn: portalArn, 
            sessionLoggerArn: sessionLoggerArn
        )
        return try await self.associateSessionLogger(input, logger: logger)
    }

    /// Associates a trust store with a web portal.
    @Sendable
    @inlinable
    public func associateTrustStore(_ input: AssociateTrustStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateTrustStoreResponse {
        try await self.client.execute(
            operation: "AssociateTrustStore", 
            path: "/portals/{portalArn+}/trustStores", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a trust store with a web portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the web portal.
    ///   - trustStoreArn: The ARN of the trust store.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateTrustStore(
        portalArn: String,
        trustStoreArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateTrustStoreResponse {
        let input = AssociateTrustStoreRequest(
            portalArn: portalArn, 
            trustStoreArn: trustStoreArn
        )
        return try await self.associateTrustStore(input, logger: logger)
    }

    /// Associates a user access logging settings resource with a web portal.
    @Sendable
    @inlinable
    public func associateUserAccessLoggingSettings(_ input: AssociateUserAccessLoggingSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateUserAccessLoggingSettingsResponse {
        try await self.client.execute(
            operation: "AssociateUserAccessLoggingSettings", 
            path: "/portals/{portalArn+}/userAccessLoggingSettings", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a user access logging settings resource with a web portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the web portal.
    ///   - userAccessLoggingSettingsArn: The ARN of the user access logging settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateUserAccessLoggingSettings(
        portalArn: String,
        userAccessLoggingSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateUserAccessLoggingSettingsResponse {
        let input = AssociateUserAccessLoggingSettingsRequest(
            portalArn: portalArn, 
            userAccessLoggingSettingsArn: userAccessLoggingSettingsArn
        )
        return try await self.associateUserAccessLoggingSettings(input, logger: logger)
    }

    /// Associates a user settings resource with a web portal.
    @Sendable
    @inlinable
    public func associateUserSettings(_ input: AssociateUserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateUserSettingsResponse {
        try await self.client.execute(
            operation: "AssociateUserSettings", 
            path: "/portals/{portalArn+}/userSettings", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a user settings resource with a web portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the web portal.
    ///   - userSettingsArn: The ARN of the user settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateUserSettings(
        portalArn: String,
        userSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateUserSettingsResponse {
        let input = AssociateUserSettingsRequest(
            portalArn: portalArn, 
            userSettingsArn: userSettingsArn
        )
        return try await self.associateUserSettings(input, logger: logger)
    }

    /// Creates a browser settings resource that can be associated with a web portal. Once associated with a web portal, browser settings control how the browser will behave once a user starts a streaming session for the web portal.
    @Sendable
    @inlinable
    public func createBrowserSettings(_ input: CreateBrowserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateBrowserSettingsResponse {
        try await self.client.execute(
            operation: "CreateBrowserSettings", 
            path: "/browserSettings", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a browser settings resource that can be associated with a web portal. Once associated with a web portal, browser settings control how the browser will behave once a user starts a streaming session for the web portal.
    ///
    /// Parameters:
    ///   - additionalEncryptionContext: Additional encryption context of the browser settings.
    ///   - browserPolicy: A JSON string containing Chrome Enterprise policies that will be applied to all streaming sessions.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token returns the result from the original successful request. If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - customerManagedKey: The custom managed key of the browser settings.
    ///   - tags: The tags to add to the browser settings resource. A tag is a key-value pair.
    ///   - logger: Logger use during operation
    @inlinable
    public func createBrowserSettings(
        additionalEncryptionContext: [String: String]? = nil,
        browserPolicy: String,
        clientToken: String? = CreateBrowserSettingsRequest.idempotencyToken(),
        customerManagedKey: String? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateBrowserSettingsResponse {
        let input = CreateBrowserSettingsRequest(
            additionalEncryptionContext: additionalEncryptionContext, 
            browserPolicy: browserPolicy, 
            clientToken: clientToken, 
            customerManagedKey: customerManagedKey, 
            tags: tags
        )
        return try await self.createBrowserSettings(input, logger: logger)
    }

    /// Creates a data protection settings resource that can be associated with a web portal.
    @Sendable
    @inlinable
    public func createDataProtectionSettings(_ input: CreateDataProtectionSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDataProtectionSettingsResponse {
        try await self.client.execute(
            operation: "CreateDataProtectionSettings", 
            path: "/dataProtectionSettings", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a data protection settings resource that can be associated with a web portal.
    ///
    /// Parameters:
    ///   - additionalEncryptionContext: Additional encryption context of the data protection settings.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token returns the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - customerManagedKey: The custom managed key of the data protection settings.
    ///   - description: The description of the data protection settings.
    ///   - displayName: The display name of the data protection settings.
    ///   - inlineRedactionConfiguration: The inline redaction configuration of the data protection settings that will be applied to all sessions.
    ///   - tags: The tags to add to the data protection settings resource. A tag is a key-value pair.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDataProtectionSettings(
        additionalEncryptionContext: [String: String]? = nil,
        clientToken: String? = CreateDataProtectionSettingsRequest.idempotencyToken(),
        customerManagedKey: String? = nil,
        description: String? = nil,
        displayName: String? = nil,
        inlineRedactionConfiguration: InlineRedactionConfiguration? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDataProtectionSettingsResponse {
        let input = CreateDataProtectionSettingsRequest(
            additionalEncryptionContext: additionalEncryptionContext, 
            clientToken: clientToken, 
            customerManagedKey: customerManagedKey, 
            description: description, 
            displayName: displayName, 
            inlineRedactionConfiguration: inlineRedactionConfiguration, 
            tags: tags
        )
        return try await self.createDataProtectionSettings(input, logger: logger)
    }

    /// Creates an identity provider resource that is then associated with a web portal.
    @Sendable
    @inlinable
    public func createIdentityProvider(_ input: CreateIdentityProviderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateIdentityProviderResponse {
        try await self.client.execute(
            operation: "CreateIdentityProvider", 
            path: "/identityProviders", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an identity provider resource that is then associated with a web portal.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token returns the result from the original successful request. If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - identityProviderDetails: The identity provider details. The following list describes the provider detail keys for each identity provider type.    For Google and Login with Amazon:    client_id     client_secret     authorize_scopes      For Facebook:    client_id     client_secret     authorize_scopes     api_version      For Sign in with Apple:    client_id     team_id     key_id     private_key     authorize_scopes      For OIDC providers:    client_id     client_secret     attributes_request_method     oidc_issuer     authorize_scopes     authorize_url if not available from discovery URL specified by oidc_issuer key     token_url if not available from discovery URL specified by oidc_issuer key     attributes_url if not available from discovery URL specified by oidc_issuer key     jwks_uri if not available from discovery URL specified by oidc_issuer key      For SAML providers:    MetadataFile OR MetadataURL     IDPSignout (boolean) optional     IDPInit (boolean) optional     RequestSigningAlgorithm (string) optional - Only accepts rsa-sha256     EncryptedResponses (boolean) optional
    ///   - identityProviderName: The identity provider name.
    ///   - identityProviderType: The identity provider type.
    ///   - portalArn: The ARN of the web portal.
    ///   - tags: The tags to add to the identity provider resource. A tag is a key-value pair.
    ///   - logger: Logger use during operation
    @inlinable
    public func createIdentityProvider(
        clientToken: String? = CreateIdentityProviderRequest.idempotencyToken(),
        identityProviderDetails: [String: String],
        identityProviderName: String,
        identityProviderType: IdentityProviderType,
        portalArn: String,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateIdentityProviderResponse {
        let input = CreateIdentityProviderRequest(
            clientToken: clientToken, 
            identityProviderDetails: identityProviderDetails, 
            identityProviderName: identityProviderName, 
            identityProviderType: identityProviderType, 
            portalArn: portalArn, 
            tags: tags
        )
        return try await self.createIdentityProvider(input, logger: logger)
    }

    /// Creates an IP access settings resource that can be associated with a web portal.
    @Sendable
    @inlinable
    public func createIpAccessSettings(_ input: CreateIpAccessSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateIpAccessSettingsResponse {
        try await self.client.execute(
            operation: "CreateIpAccessSettings", 
            path: "/ipAccessSettings", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an IP access settings resource that can be associated with a web portal.
    ///
    /// Parameters:
    ///   - additionalEncryptionContext: Additional encryption context of the IP access settings.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token returns the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - customerManagedKey: The custom managed key of the IP access settings.
    ///   - description: The description of the IP access settings.
    ///   - displayName: The display name of the IP access settings.
    ///   - ipRules: The IP rules of the IP access settings.
    ///   - tags: The tags to add to the IP access settings resource. A tag is a key-value pair.
    ///   - logger: Logger use during operation
    @inlinable
    public func createIpAccessSettings(
        additionalEncryptionContext: [String: String]? = nil,
        clientToken: String? = CreateIpAccessSettingsRequest.idempotencyToken(),
        customerManagedKey: String? = nil,
        description: String? = nil,
        displayName: String? = nil,
        ipRules: [IpRule],
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateIpAccessSettingsResponse {
        let input = CreateIpAccessSettingsRequest(
            additionalEncryptionContext: additionalEncryptionContext, 
            clientToken: clientToken, 
            customerManagedKey: customerManagedKey, 
            description: description, 
            displayName: displayName, 
            ipRules: ipRules, 
            tags: tags
        )
        return try await self.createIpAccessSettings(input, logger: logger)
    }

    /// Creates a network settings resource that can be associated with a web portal. Once associated with a web portal, network settings define how streaming instances will connect with your specified VPC.
    @Sendable
    @inlinable
    public func createNetworkSettings(_ input: CreateNetworkSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateNetworkSettingsResponse {
        try await self.client.execute(
            operation: "CreateNetworkSettings", 
            path: "/networkSettings", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a network settings resource that can be associated with a web portal. Once associated with a web portal, network settings define how streaming instances will connect with your specified VPC.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token returns the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - securityGroupIds: One or more security groups used to control access from streaming instances to your VPC.
    ///   - subnetIds: The subnets in which network interfaces are created to connect streaming instances to your VPC. At least two of these subnets must be in different availability zones.
    ///   - tags: The tags to add to the network settings resource. A tag is a key-value pair.
    ///   - vpcId: The VPC that streaming instances will connect to.
    ///   - logger: Logger use during operation
    @inlinable
    public func createNetworkSettings(
        clientToken: String? = CreateNetworkSettingsRequest.idempotencyToken(),
        securityGroupIds: [String],
        subnetIds: [String],
        tags: [Tag]? = nil,
        vpcId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateNetworkSettingsResponse {
        let input = CreateNetworkSettingsRequest(
            clientToken: clientToken, 
            securityGroupIds: securityGroupIds, 
            subnetIds: subnetIds, 
            tags: tags, 
            vpcId: vpcId
        )
        return try await self.createNetworkSettings(input, logger: logger)
    }

    /// Creates a web portal.
    @Sendable
    @inlinable
    public func createPortal(_ input: CreatePortalRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreatePortalResponse {
        try await self.client.execute(
            operation: "CreatePortal", 
            path: "/portals", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a web portal.
    ///
    /// Parameters:
    ///   - additionalEncryptionContext: The additional encryption context of the portal.
    ///   - authenticationType: The type of authentication integration points used when signing into the web portal. Defaults to Standard.  Standard web portals are authenticated directly through your identity provider. You need to call CreateIdentityProvider to integrate your identity provider with your web portal. User and group access to your web portal is controlled through your identity provider.  IAM Identity Center web portals are authenticated through IAM Identity Center. Identity sources (including external identity provider integration), plus user and group access to your web portal, can be configured in the IAM Identity Center.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token returns the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - customerManagedKey: The customer managed key of the web portal.
    ///   - displayName: The name of the web portal. This is not visible to users who log into the web portal.
    ///   - instanceType: The type and resources of the underlying instance.
    ///   - maxConcurrentSessions: The maximum number of concurrent sessions for the portal.
    ///   - tags: The tags to add to the web portal. A tag is a key-value pair.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPortal(
        additionalEncryptionContext: [String: String]? = nil,
        authenticationType: AuthenticationType? = nil,
        clientToken: String? = CreatePortalRequest.idempotencyToken(),
        customerManagedKey: String? = nil,
        displayName: String? = nil,
        instanceType: InstanceType? = nil,
        maxConcurrentSessions: Int? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreatePortalResponse {
        let input = CreatePortalRequest(
            additionalEncryptionContext: additionalEncryptionContext, 
            authenticationType: authenticationType, 
            clientToken: clientToken, 
            customerManagedKey: customerManagedKey, 
            displayName: displayName, 
            instanceType: instanceType, 
            maxConcurrentSessions: maxConcurrentSessions, 
            tags: tags
        )
        return try await self.createPortal(input, logger: logger)
    }

    /// Creates a session logger.
    @Sendable
    @inlinable
    public func createSessionLogger(_ input: CreateSessionLoggerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSessionLoggerResponse {
        try await self.client.execute(
            operation: "CreateSessionLogger", 
            path: "/sessionLoggers", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a session logger.
    ///
    /// Parameters:
    ///   - additionalEncryptionContext: The additional encryption context of the session logger.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token returns the result from the original successful request. If you do not specify a client token, one is automatically generated by the AWS SDK.
    ///   - customerManagedKey: The custom managed key of the session logger.
    ///   - displayName: The human-readable display name for the session logger resource.
    ///   - eventFilter: The filter that specifies the events to monitor.
    ///   - logConfiguration: The configuration that specifies where logs are delivered.
    ///   - tags: The tags to add to the session logger.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSessionLogger(
        additionalEncryptionContext: [String: String]? = nil,
        clientToken: String? = CreateSessionLoggerRequest.idempotencyToken(),
        customerManagedKey: String? = nil,
        displayName: String? = nil,
        eventFilter: EventFilter,
        logConfiguration: LogConfiguration,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSessionLoggerResponse {
        let input = CreateSessionLoggerRequest(
            additionalEncryptionContext: additionalEncryptionContext, 
            clientToken: clientToken, 
            customerManagedKey: customerManagedKey, 
            displayName: displayName, 
            eventFilter: eventFilter, 
            logConfiguration: logConfiguration, 
            tags: tags
        )
        return try await self.createSessionLogger(input, logger: logger)
    }

    /// Creates a trust store that can be associated with a web portal. A trust store contains certificate authority (CA) certificates. Once associated with a web portal, the browser in a streaming session will recognize certificates that have been issued using any of the CAs in the trust store. If your organization has internal websites that use certificates issued by private CAs, you should add the private CA certificate to the trust store.
    @Sendable
    @inlinable
    public func createTrustStore(_ input: CreateTrustStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateTrustStoreResponse {
        try await self.client.execute(
            operation: "CreateTrustStore", 
            path: "/trustStores", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a trust store that can be associated with a web portal. A trust store contains certificate authority (CA) certificates. Once associated with a web portal, the browser in a streaming session will recognize certificates that have been issued using any of the CAs in the trust store. If your organization has internal websites that use certificates issued by private CAs, you should add the private CA certificate to the trust store.
    ///
    /// Parameters:
    ///   - certificateList: A list of CA certificates to be added to the trust store.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token returns the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - tags: The tags to add to the trust store. A tag is a key-value pair.
    ///   - logger: Logger use during operation
    @inlinable
    public func createTrustStore(
        certificateList: [AWSBase64Data],
        clientToken: String? = CreateTrustStoreRequest.idempotencyToken(),
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateTrustStoreResponse {
        let input = CreateTrustStoreRequest(
            certificateList: certificateList, 
            clientToken: clientToken, 
            tags: tags
        )
        return try await self.createTrustStore(input, logger: logger)
    }

    /// Creates a user access logging settings resource that can be associated with a web portal.
    @Sendable
    @inlinable
    public func createUserAccessLoggingSettings(_ input: CreateUserAccessLoggingSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateUserAccessLoggingSettingsResponse {
        try await self.client.execute(
            operation: "CreateUserAccessLoggingSettings", 
            path: "/userAccessLoggingSettings", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a user access logging settings resource that can be associated with a web portal.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token returns the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - kinesisStreamArn: The ARN of the Kinesis stream.
    ///   - tags: The tags to add to the user settings resource. A tag is a key-value pair.
    ///   - logger: Logger use during operation
    @inlinable
    public func createUserAccessLoggingSettings(
        clientToken: String? = CreateUserAccessLoggingSettingsRequest.idempotencyToken(),
        kinesisStreamArn: String,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateUserAccessLoggingSettingsResponse {
        let input = CreateUserAccessLoggingSettingsRequest(
            clientToken: clientToken, 
            kinesisStreamArn: kinesisStreamArn, 
            tags: tags
        )
        return try await self.createUserAccessLoggingSettings(input, logger: logger)
    }

    /// Creates a user settings resource that can be associated with a web portal. Once associated with a web portal, user settings control how users can transfer data between a streaming session and the their local devices.
    @Sendable
    @inlinable
    public func createUserSettings(_ input: CreateUserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateUserSettingsResponse {
        try await self.client.execute(
            operation: "CreateUserSettings", 
            path: "/userSettings", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a user settings resource that can be associated with a web portal. Once associated with a web portal, user settings control how users can transfer data between a streaming session and the their local devices.
    ///
    /// Parameters:
    ///   - additionalEncryptionContext: The additional encryption context of the user settings.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token returns the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - cookieSynchronizationConfiguration: The configuration that specifies which cookies should be synchronized from the end user's local browser to the remote browser.
    ///   - copyAllowed: Specifies whether the user can copy text from the streaming session to the local device.
    ///   - customerManagedKey: The customer managed key used to encrypt sensitive information in the user settings.
    ///   - deepLinkAllowed: Specifies whether the user can use deep links that open automatically when connecting to a session.
    ///   - disconnectTimeoutInMinutes: The amount of time that a streaming session remains active after users disconnect.
    ///   - downloadAllowed: Specifies whether the user can download files from the streaming session to the local device.
    ///   - idleDisconnectTimeoutInMinutes: The amount of time that users can be idle (inactive) before they are disconnected from their streaming session and the disconnect timeout interval begins.
    ///   - pasteAllowed: Specifies whether the user can paste text from the local device to the streaming session.
    ///   - printAllowed: Specifies whether the user can print to the local device.
    ///   - tags: The tags to add to the user settings resource. A tag is a key-value pair.
    ///   - toolbarConfiguration: The configuration of the toolbar. This allows administrators to select the toolbar type and visual mode, set maximum display resolution for sessions, and choose which items are visible to end users during their sessions. If administrators do not modify these settings, end users retain control over their toolbar preferences.
    ///   - uploadAllowed: Specifies whether the user can upload files from the local device to the streaming session.
    ///   - logger: Logger use during operation
    @inlinable
    public func createUserSettings(
        additionalEncryptionContext: [String: String]? = nil,
        clientToken: String? = CreateUserSettingsRequest.idempotencyToken(),
        cookieSynchronizationConfiguration: CookieSynchronizationConfiguration? = nil,
        copyAllowed: EnabledType,
        customerManagedKey: String? = nil,
        deepLinkAllowed: EnabledType? = nil,
        disconnectTimeoutInMinutes: Int? = nil,
        downloadAllowed: EnabledType,
        idleDisconnectTimeoutInMinutes: Int? = nil,
        pasteAllowed: EnabledType,
        printAllowed: EnabledType,
        tags: [Tag]? = nil,
        toolbarConfiguration: ToolbarConfiguration? = nil,
        uploadAllowed: EnabledType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateUserSettingsResponse {
        let input = CreateUserSettingsRequest(
            additionalEncryptionContext: additionalEncryptionContext, 
            clientToken: clientToken, 
            cookieSynchronizationConfiguration: cookieSynchronizationConfiguration, 
            copyAllowed: copyAllowed, 
            customerManagedKey: customerManagedKey, 
            deepLinkAllowed: deepLinkAllowed, 
            disconnectTimeoutInMinutes: disconnectTimeoutInMinutes, 
            downloadAllowed: downloadAllowed, 
            idleDisconnectTimeoutInMinutes: idleDisconnectTimeoutInMinutes, 
            pasteAllowed: pasteAllowed, 
            printAllowed: printAllowed, 
            tags: tags, 
            toolbarConfiguration: toolbarConfiguration, 
            uploadAllowed: uploadAllowed
        )
        return try await self.createUserSettings(input, logger: logger)
    }

    /// Deletes browser settings.
    @Sendable
    @inlinable
    public func deleteBrowserSettings(_ input: DeleteBrowserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteBrowserSettingsResponse {
        try await self.client.execute(
            operation: "DeleteBrowserSettings", 
            path: "/browserSettings/{browserSettingsArn+}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes browser settings.
    ///
    /// Parameters:
    ///   - browserSettingsArn: The ARN of the browser settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteBrowserSettings(
        browserSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteBrowserSettingsResponse {
        let input = DeleteBrowserSettingsRequest(
            browserSettingsArn: browserSettingsArn
        )
        return try await self.deleteBrowserSettings(input, logger: logger)
    }

    /// Deletes data protection settings.
    @Sendable
    @inlinable
    public func deleteDataProtectionSettings(_ input: DeleteDataProtectionSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteDataProtectionSettingsResponse {
        try await self.client.execute(
            operation: "DeleteDataProtectionSettings", 
            path: "/dataProtectionSettings/{dataProtectionSettingsArn+}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes data protection settings.
    ///
    /// Parameters:
    ///   - dataProtectionSettingsArn: The ARN of the data protection settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDataProtectionSettings(
        dataProtectionSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteDataProtectionSettingsResponse {
        let input = DeleteDataProtectionSettingsRequest(
            dataProtectionSettingsArn: dataProtectionSettingsArn
        )
        return try await self.deleteDataProtectionSettings(input, logger: logger)
    }

    /// Deletes the identity provider.
    @Sendable
    @inlinable
    public func deleteIdentityProvider(_ input: DeleteIdentityProviderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteIdentityProviderResponse {
        try await self.client.execute(
            operation: "DeleteIdentityProvider", 
            path: "/identityProviders/{identityProviderArn+}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the identity provider.
    ///
    /// Parameters:
    ///   - identityProviderArn: The ARN of the identity provider.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteIdentityProvider(
        identityProviderArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteIdentityProviderResponse {
        let input = DeleteIdentityProviderRequest(
            identityProviderArn: identityProviderArn
        )
        return try await self.deleteIdentityProvider(input, logger: logger)
    }

    /// Deletes IP access settings.
    @Sendable
    @inlinable
    public func deleteIpAccessSettings(_ input: DeleteIpAccessSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteIpAccessSettingsResponse {
        try await self.client.execute(
            operation: "DeleteIpAccessSettings", 
            path: "/ipAccessSettings/{ipAccessSettingsArn+}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes IP access settings.
    ///
    /// Parameters:
    ///   - ipAccessSettingsArn: The ARN of the IP access settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteIpAccessSettings(
        ipAccessSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteIpAccessSettingsResponse {
        let input = DeleteIpAccessSettingsRequest(
            ipAccessSettingsArn: ipAccessSettingsArn
        )
        return try await self.deleteIpAccessSettings(input, logger: logger)
    }

    /// Deletes network settings.
    @Sendable
    @inlinable
    public func deleteNetworkSettings(_ input: DeleteNetworkSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteNetworkSettingsResponse {
        try await self.client.execute(
            operation: "DeleteNetworkSettings", 
            path: "/networkSettings/{networkSettingsArn+}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes network settings.
    ///
    /// Parameters:
    ///   - networkSettingsArn: The ARN of the network settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteNetworkSettings(
        networkSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteNetworkSettingsResponse {
        let input = DeleteNetworkSettingsRequest(
            networkSettingsArn: networkSettingsArn
        )
        return try await self.deleteNetworkSettings(input, logger: logger)
    }

    /// Deletes a web portal.
    @Sendable
    @inlinable
    public func deletePortal(_ input: DeletePortalRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeletePortalResponse {
        try await self.client.execute(
            operation: "DeletePortal", 
            path: "/portals/{portalArn+}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a web portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func deletePortal(
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeletePortalResponse {
        let input = DeletePortalRequest(
            portalArn: portalArn
        )
        return try await self.deletePortal(input, logger: logger)
    }

    /// Deletes a session logger resource.
    @Sendable
    @inlinable
    public func deleteSessionLogger(_ input: DeleteSessionLoggerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSessionLoggerResponse {
        try await self.client.execute(
            operation: "DeleteSessionLogger", 
            path: "/sessionLoggers/{sessionLoggerArn+}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a session logger resource.
    ///
    /// Parameters:
    ///   - sessionLoggerArn: The ARN of the session logger.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSessionLogger(
        sessionLoggerArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSessionLoggerResponse {
        let input = DeleteSessionLoggerRequest(
            sessionLoggerArn: sessionLoggerArn
        )
        return try await self.deleteSessionLogger(input, logger: logger)
    }

    /// Deletes the trust store.
    @Sendable
    @inlinable
    public func deleteTrustStore(_ input: DeleteTrustStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteTrustStoreResponse {
        try await self.client.execute(
            operation: "DeleteTrustStore", 
            path: "/trustStores/{trustStoreArn+}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the trust store.
    ///
    /// Parameters:
    ///   - trustStoreArn: The ARN of the trust store.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteTrustStore(
        trustStoreArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteTrustStoreResponse {
        let input = DeleteTrustStoreRequest(
            trustStoreArn: trustStoreArn
        )
        return try await self.deleteTrustStore(input, logger: logger)
    }

    /// Deletes user access logging settings.
    @Sendable
    @inlinable
    public func deleteUserAccessLoggingSettings(_ input: DeleteUserAccessLoggingSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteUserAccessLoggingSettingsResponse {
        try await self.client.execute(
            operation: "DeleteUserAccessLoggingSettings", 
            path: "/userAccessLoggingSettings/{userAccessLoggingSettingsArn+}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes user access logging settings.
    ///
    /// Parameters:
    ///   - userAccessLoggingSettingsArn: The ARN of the user access logging settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteUserAccessLoggingSettings(
        userAccessLoggingSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteUserAccessLoggingSettingsResponse {
        let input = DeleteUserAccessLoggingSettingsRequest(
            userAccessLoggingSettingsArn: userAccessLoggingSettingsArn
        )
        return try await self.deleteUserAccessLoggingSettings(input, logger: logger)
    }

    /// Deletes user settings.
    @Sendable
    @inlinable
    public func deleteUserSettings(_ input: DeleteUserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteUserSettingsResponse {
        try await self.client.execute(
            operation: "DeleteUserSettings", 
            path: "/userSettings/{userSettingsArn+}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes user settings.
    ///
    /// Parameters:
    ///   - userSettingsArn: The ARN of the user settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteUserSettings(
        userSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteUserSettingsResponse {
        let input = DeleteUserSettingsRequest(
            userSettingsArn: userSettingsArn
        )
        return try await self.deleteUserSettings(input, logger: logger)
    }

    /// Disassociates browser settings from a web portal.
    @Sendable
    @inlinable
    public func disassociateBrowserSettings(_ input: DisassociateBrowserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateBrowserSettingsResponse {
        try await self.client.execute(
            operation: "DisassociateBrowserSettings", 
            path: "/portals/{portalArn+}/browserSettings", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates browser settings from a web portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateBrowserSettings(
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateBrowserSettingsResponse {
        let input = DisassociateBrowserSettingsRequest(
            portalArn: portalArn
        )
        return try await self.disassociateBrowserSettings(input, logger: logger)
    }

    /// Disassociates data protection settings from a web portal.
    @Sendable
    @inlinable
    public func disassociateDataProtectionSettings(_ input: DisassociateDataProtectionSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateDataProtectionSettingsResponse {
        try await self.client.execute(
            operation: "DisassociateDataProtectionSettings", 
            path: "/portals/{portalArn+}/dataProtectionSettings", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates data protection settings from a web portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateDataProtectionSettings(
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateDataProtectionSettingsResponse {
        let input = DisassociateDataProtectionSettingsRequest(
            portalArn: portalArn
        )
        return try await self.disassociateDataProtectionSettings(input, logger: logger)
    }

    /// Disassociates IP access settings from a web portal.
    @Sendable
    @inlinable
    public func disassociateIpAccessSettings(_ input: DisassociateIpAccessSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateIpAccessSettingsResponse {
        try await self.client.execute(
            operation: "DisassociateIpAccessSettings", 
            path: "/portals/{portalArn+}/ipAccessSettings", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates IP access settings from a web portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateIpAccessSettings(
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateIpAccessSettingsResponse {
        let input = DisassociateIpAccessSettingsRequest(
            portalArn: portalArn
        )
        return try await self.disassociateIpAccessSettings(input, logger: logger)
    }

    /// Disassociates network settings from a web portal.
    @Sendable
    @inlinable
    public func disassociateNetworkSettings(_ input: DisassociateNetworkSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateNetworkSettingsResponse {
        try await self.client.execute(
            operation: "DisassociateNetworkSettings", 
            path: "/portals/{portalArn+}/networkSettings", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates network settings from a web portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateNetworkSettings(
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateNetworkSettingsResponse {
        let input = DisassociateNetworkSettingsRequest(
            portalArn: portalArn
        )
        return try await self.disassociateNetworkSettings(input, logger: logger)
    }

    /// Disassociates a session logger from a portal.
    @Sendable
    @inlinable
    public func disassociateSessionLogger(_ input: DisassociateSessionLoggerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateSessionLoggerResponse {
        try await self.client.execute(
            operation: "DisassociateSessionLogger", 
            path: "/portals/{portalArn+}/sessionLogger", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a session logger from a portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the portal to disassociate from the a session logger.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateSessionLogger(
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateSessionLoggerResponse {
        let input = DisassociateSessionLoggerRequest(
            portalArn: portalArn
        )
        return try await self.disassociateSessionLogger(input, logger: logger)
    }

    /// Disassociates a trust store from a web portal.
    @Sendable
    @inlinable
    public func disassociateTrustStore(_ input: DisassociateTrustStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateTrustStoreResponse {
        try await self.client.execute(
            operation: "DisassociateTrustStore", 
            path: "/portals/{portalArn+}/trustStores", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a trust store from a web portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateTrustStore(
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateTrustStoreResponse {
        let input = DisassociateTrustStoreRequest(
            portalArn: portalArn
        )
        return try await self.disassociateTrustStore(input, logger: logger)
    }

    /// Disassociates user access logging settings from a web portal.
    @Sendable
    @inlinable
    public func disassociateUserAccessLoggingSettings(_ input: DisassociateUserAccessLoggingSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateUserAccessLoggingSettingsResponse {
        try await self.client.execute(
            operation: "DisassociateUserAccessLoggingSettings", 
            path: "/portals/{portalArn+}/userAccessLoggingSettings", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates user access logging settings from a web portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateUserAccessLoggingSettings(
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateUserAccessLoggingSettingsResponse {
        let input = DisassociateUserAccessLoggingSettingsRequest(
            portalArn: portalArn
        )
        return try await self.disassociateUserAccessLoggingSettings(input, logger: logger)
    }

    /// Disassociates user settings from a web portal.
    @Sendable
    @inlinable
    public func disassociateUserSettings(_ input: DisassociateUserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateUserSettingsResponse {
        try await self.client.execute(
            operation: "DisassociateUserSettings", 
            path: "/portals/{portalArn+}/userSettings", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates user settings from a web portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateUserSettings(
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateUserSettingsResponse {
        let input = DisassociateUserSettingsRequest(
            portalArn: portalArn
        )
        return try await self.disassociateUserSettings(input, logger: logger)
    }

    /// Expires an active secure browser session.
    @Sendable
    @inlinable
    public func expireSession(_ input: ExpireSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ExpireSessionResponse {
        try await self.client.execute(
            operation: "ExpireSession", 
            path: "/portals/{portalId}/sessions/{sessionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Expires an active secure browser session.
    ///
    /// Parameters:
    ///   - portalId: The ID of the web portal for the session.
    ///   - sessionId: The ID of the session to expire.
    ///   - logger: Logger use during operation
    @inlinable
    public func expireSession(
        portalId: String,
        sessionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ExpireSessionResponse {
        let input = ExpireSessionRequest(
            portalId: portalId, 
            sessionId: sessionId
        )
        return try await self.expireSession(input, logger: logger)
    }

    /// Gets browser settings.
    @Sendable
    @inlinable
    public func getBrowserSettings(_ input: GetBrowserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetBrowserSettingsResponse {
        try await self.client.execute(
            operation: "GetBrowserSettings", 
            path: "/browserSettings/{browserSettingsArn+}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets browser settings.
    ///
    /// Parameters:
    ///   - browserSettingsArn: The ARN of the browser settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func getBrowserSettings(
        browserSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetBrowserSettingsResponse {
        let input = GetBrowserSettingsRequest(
            browserSettingsArn: browserSettingsArn
        )
        return try await self.getBrowserSettings(input, logger: logger)
    }

    /// Gets the data protection settings.
    @Sendable
    @inlinable
    public func getDataProtectionSettings(_ input: GetDataProtectionSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDataProtectionSettingsResponse {
        try await self.client.execute(
            operation: "GetDataProtectionSettings", 
            path: "/dataProtectionSettings/{dataProtectionSettingsArn+}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the data protection settings.
    ///
    /// Parameters:
    ///   - dataProtectionSettingsArn: The ARN of the data protection settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDataProtectionSettings(
        dataProtectionSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDataProtectionSettingsResponse {
        let input = GetDataProtectionSettingsRequest(
            dataProtectionSettingsArn: dataProtectionSettingsArn
        )
        return try await self.getDataProtectionSettings(input, logger: logger)
    }

    /// Gets the identity provider.
    @Sendable
    @inlinable
    public func getIdentityProvider(_ input: GetIdentityProviderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetIdentityProviderResponse {
        try await self.client.execute(
            operation: "GetIdentityProvider", 
            path: "/identityProviders/{identityProviderArn+}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the identity provider.
    ///
    /// Parameters:
    ///   - identityProviderArn: The ARN of the identity provider.
    ///   - logger: Logger use during operation
    @inlinable
    public func getIdentityProvider(
        identityProviderArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetIdentityProviderResponse {
        let input = GetIdentityProviderRequest(
            identityProviderArn: identityProviderArn
        )
        return try await self.getIdentityProvider(input, logger: logger)
    }

    /// Gets the IP access settings.
    @Sendable
    @inlinable
    public func getIpAccessSettings(_ input: GetIpAccessSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetIpAccessSettingsResponse {
        try await self.client.execute(
            operation: "GetIpAccessSettings", 
            path: "/ipAccessSettings/{ipAccessSettingsArn+}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the IP access settings.
    ///
    /// Parameters:
    ///   - ipAccessSettingsArn: The ARN of the IP access settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func getIpAccessSettings(
        ipAccessSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetIpAccessSettingsResponse {
        let input = GetIpAccessSettingsRequest(
            ipAccessSettingsArn: ipAccessSettingsArn
        )
        return try await self.getIpAccessSettings(input, logger: logger)
    }

    /// Gets the network settings.
    @Sendable
    @inlinable
    public func getNetworkSettings(_ input: GetNetworkSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNetworkSettingsResponse {
        try await self.client.execute(
            operation: "GetNetworkSettings", 
            path: "/networkSettings/{networkSettingsArn+}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the network settings.
    ///
    /// Parameters:
    ///   - networkSettingsArn: The ARN of the network settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func getNetworkSettings(
        networkSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNetworkSettingsResponse {
        let input = GetNetworkSettingsRequest(
            networkSettingsArn: networkSettingsArn
        )
        return try await self.getNetworkSettings(input, logger: logger)
    }

    /// Gets the web portal.
    @Sendable
    @inlinable
    public func getPortal(_ input: GetPortalRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPortalResponse {
        try await self.client.execute(
            operation: "GetPortal", 
            path: "/portals/{portalArn+}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the web portal.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPortal(
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPortalResponse {
        let input = GetPortalRequest(
            portalArn: portalArn
        )
        return try await self.getPortal(input, logger: logger)
    }

    /// Gets the service provider metadata.
    @Sendable
    @inlinable
    public func getPortalServiceProviderMetadata(_ input: GetPortalServiceProviderMetadataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPortalServiceProviderMetadataResponse {
        try await self.client.execute(
            operation: "GetPortalServiceProviderMetadata", 
            path: "/portalIdp/{portalArn+}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the service provider metadata.
    ///
    /// Parameters:
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPortalServiceProviderMetadata(
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPortalServiceProviderMetadataResponse {
        let input = GetPortalServiceProviderMetadataRequest(
            portalArn: portalArn
        )
        return try await self.getPortalServiceProviderMetadata(input, logger: logger)
    }

    /// Gets information for a secure browser session.
    @Sendable
    @inlinable
    public func getSession(_ input: GetSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSessionResponse {
        try await self.client.execute(
            operation: "GetSession", 
            path: "/portals/{portalId}/sessions/{sessionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information for a secure browser session.
    ///
    /// Parameters:
    ///   - portalId: The ID of the web portal for the session.
    ///   - sessionId: The ID of the session.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSession(
        portalId: String,
        sessionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSessionResponse {
        let input = GetSessionRequest(
            portalId: portalId, 
            sessionId: sessionId
        )
        return try await self.getSession(input, logger: logger)
    }

    /// Gets details about a specific session logger resource.
    @Sendable
    @inlinable
    public func getSessionLogger(_ input: GetSessionLoggerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSessionLoggerResponse {
        try await self.client.execute(
            operation: "GetSessionLogger", 
            path: "/sessionLoggers/{sessionLoggerArn+}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details about a specific session logger resource.
    ///
    /// Parameters:
    ///   - sessionLoggerArn: The ARN of the session logger.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSessionLogger(
        sessionLoggerArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSessionLoggerResponse {
        let input = GetSessionLoggerRequest(
            sessionLoggerArn: sessionLoggerArn
        )
        return try await self.getSessionLogger(input, logger: logger)
    }

    /// Gets the trust store.
    @Sendable
    @inlinable
    public func getTrustStore(_ input: GetTrustStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTrustStoreResponse {
        try await self.client.execute(
            operation: "GetTrustStore", 
            path: "/trustStores/{trustStoreArn+}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the trust store.
    ///
    /// Parameters:
    ///   - trustStoreArn: The ARN of the trust store.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTrustStore(
        trustStoreArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTrustStoreResponse {
        let input = GetTrustStoreRequest(
            trustStoreArn: trustStoreArn
        )
        return try await self.getTrustStore(input, logger: logger)
    }

    /// Gets the trust store certificate.
    @Sendable
    @inlinable
    public func getTrustStoreCertificate(_ input: GetTrustStoreCertificateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTrustStoreCertificateResponse {
        try await self.client.execute(
            operation: "GetTrustStoreCertificate", 
            path: "/trustStores/{trustStoreArn+}/certificate", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the trust store certificate.
    ///
    /// Parameters:
    ///   - thumbprint: The thumbprint of the trust store certificate.
    ///   - trustStoreArn: The ARN of the trust store certificate.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTrustStoreCertificate(
        thumbprint: String,
        trustStoreArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTrustStoreCertificateResponse {
        let input = GetTrustStoreCertificateRequest(
            thumbprint: thumbprint, 
            trustStoreArn: trustStoreArn
        )
        return try await self.getTrustStoreCertificate(input, logger: logger)
    }

    /// Gets user access logging settings.
    @Sendable
    @inlinable
    public func getUserAccessLoggingSettings(_ input: GetUserAccessLoggingSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetUserAccessLoggingSettingsResponse {
        try await self.client.execute(
            operation: "GetUserAccessLoggingSettings", 
            path: "/userAccessLoggingSettings/{userAccessLoggingSettingsArn+}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets user access logging settings.
    ///
    /// Parameters:
    ///   - userAccessLoggingSettingsArn: The ARN of the user access logging settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func getUserAccessLoggingSettings(
        userAccessLoggingSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetUserAccessLoggingSettingsResponse {
        let input = GetUserAccessLoggingSettingsRequest(
            userAccessLoggingSettingsArn: userAccessLoggingSettingsArn
        )
        return try await self.getUserAccessLoggingSettings(input, logger: logger)
    }

    /// Gets user settings.
    @Sendable
    @inlinable
    public func getUserSettings(_ input: GetUserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetUserSettingsResponse {
        try await self.client.execute(
            operation: "GetUserSettings", 
            path: "/userSettings/{userSettingsArn+}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets user settings.
    ///
    /// Parameters:
    ///   - userSettingsArn: The ARN of the user settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func getUserSettings(
        userSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetUserSettingsResponse {
        let input = GetUserSettingsRequest(
            userSettingsArn: userSettingsArn
        )
        return try await self.getUserSettings(input, logger: logger)
    }

    /// Retrieves a list of browser settings.
    @Sendable
    @inlinable
    public func listBrowserSettings(_ input: ListBrowserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListBrowserSettingsResponse {
        try await self.client.execute(
            operation: "ListBrowserSettings", 
            path: "/browserSettings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of browser settings.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listBrowserSettings(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListBrowserSettingsResponse {
        let input = ListBrowserSettingsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listBrowserSettings(input, logger: logger)
    }

    /// Retrieves a list of data protection settings.
    @Sendable
    @inlinable
    public func listDataProtectionSettings(_ input: ListDataProtectionSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDataProtectionSettingsResponse {
        try await self.client.execute(
            operation: "ListDataProtectionSettings", 
            path: "/dataProtectionSettings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of data protection settings.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDataProtectionSettings(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDataProtectionSettingsResponse {
        let input = ListDataProtectionSettingsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDataProtectionSettings(input, logger: logger)
    }

    /// Retrieves a list of identity providers for a specific web portal.
    @Sendable
    @inlinable
    public func listIdentityProviders(_ input: ListIdentityProvidersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListIdentityProvidersResponse {
        try await self.client.execute(
            operation: "ListIdentityProviders", 
            path: "/portals/{portalArn+}/identityProviders", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of identity providers for a specific web portal.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func listIdentityProviders(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListIdentityProvidersResponse {
        let input = ListIdentityProvidersRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            portalArn: portalArn
        )
        return try await self.listIdentityProviders(input, logger: logger)
    }

    /// Retrieves a list of IP access settings.
    @Sendable
    @inlinable
    public func listIpAccessSettings(_ input: ListIpAccessSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListIpAccessSettingsResponse {
        try await self.client.execute(
            operation: "ListIpAccessSettings", 
            path: "/ipAccessSettings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of IP access settings.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listIpAccessSettings(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListIpAccessSettingsResponse {
        let input = ListIpAccessSettingsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listIpAccessSettings(input, logger: logger)
    }

    /// Retrieves a list of network settings.
    @Sendable
    @inlinable
    public func listNetworkSettings(_ input: ListNetworkSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListNetworkSettingsResponse {
        try await self.client.execute(
            operation: "ListNetworkSettings", 
            path: "/networkSettings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of network settings.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listNetworkSettings(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListNetworkSettingsResponse {
        let input = ListNetworkSettingsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listNetworkSettings(input, logger: logger)
    }

    /// Retrieves a list or web portals.
    @Sendable
    @inlinable
    public func listPortals(_ input: ListPortalsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPortalsResponse {
        try await self.client.execute(
            operation: "ListPortals", 
            path: "/portals", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list or web portals.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPortals(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPortalsResponse {
        let input = ListPortalsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listPortals(input, logger: logger)
    }

    /// Lists all available session logger resources.
    @Sendable
    @inlinable
    public func listSessionLoggers(_ input: ListSessionLoggersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSessionLoggersResponse {
        try await self.client.execute(
            operation: "ListSessionLoggers", 
            path: "/sessionLoggers", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all available session logger resources.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSessionLoggers(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSessionLoggersResponse {
        let input = ListSessionLoggersRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSessionLoggers(input, logger: logger)
    }

    /// Lists information for multiple secure browser sessions from a specific portal.
    @Sendable
    @inlinable
    public func listSessions(_ input: ListSessionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSessionsResponse {
        try await self.client.execute(
            operation: "ListSessions", 
            path: "/portals/{portalId}/sessions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists information for multiple secure browser sessions from a specific portal.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - portalId: The ID of the web portal for the sessions.
    ///   - sessionId: The ID of the session.
    ///   - sortBy: The method in which the returned sessions should be sorted.
    ///   - status: The status of the session.
    ///   - username: The username of the session.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSessions(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        portalId: String,
        sessionId: String? = nil,
        sortBy: SessionSortBy? = nil,
        status: SessionStatus? = nil,
        username: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSessionsResponse {
        let input = ListSessionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            portalId: portalId, 
            sessionId: sessionId, 
            sortBy: sortBy, 
            status: status, 
            username: username
        )
        return try await self.listSessions(input, logger: logger)
    }

    /// Retrieves a list of tags for a resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn+}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of tags for a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The ARN of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Retrieves a list of trust store certificates.
    @Sendable
    @inlinable
    public func listTrustStoreCertificates(_ input: ListTrustStoreCertificatesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTrustStoreCertificatesResponse {
        try await self.client.execute(
            operation: "ListTrustStoreCertificates", 
            path: "/trustStores/{trustStoreArn+}/certificates", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of trust store certificates.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - trustStoreArn: The ARN of the trust store
    ///   - logger: Logger use during operation
    @inlinable
    public func listTrustStoreCertificates(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        trustStoreArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTrustStoreCertificatesResponse {
        let input = ListTrustStoreCertificatesRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            trustStoreArn: trustStoreArn
        )
        return try await self.listTrustStoreCertificates(input, logger: logger)
    }

    /// Retrieves a list of trust stores.
    @Sendable
    @inlinable
    public func listTrustStores(_ input: ListTrustStoresRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTrustStoresResponse {
        try await self.client.execute(
            operation: "ListTrustStores", 
            path: "/trustStores", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of trust stores.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTrustStores(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTrustStoresResponse {
        let input = ListTrustStoresRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listTrustStores(input, logger: logger)
    }

    /// Retrieves a list of user access logging settings.
    @Sendable
    @inlinable
    public func listUserAccessLoggingSettings(_ input: ListUserAccessLoggingSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListUserAccessLoggingSettingsResponse {
        try await self.client.execute(
            operation: "ListUserAccessLoggingSettings", 
            path: "/userAccessLoggingSettings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of user access logging settings.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listUserAccessLoggingSettings(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListUserAccessLoggingSettingsResponse {
        let input = ListUserAccessLoggingSettingsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listUserAccessLoggingSettings(input, logger: logger)
    }

    /// Retrieves a list of user settings.
    @Sendable
    @inlinable
    public func listUserSettings(_ input: ListUserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListUserSettingsResponse {
        try await self.client.execute(
            operation: "ListUserSettings", 
            path: "/userSettings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of user settings.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - nextToken: The pagination token used to retrieve the next page of results for this operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listUserSettings(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListUserSettingsResponse {
        let input = ListUserSettingsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listUserSettings(input, logger: logger)
    }

    /// Adds or overwrites one or more tags for the specified resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn+}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds or overwrites one or more tags for the specified resource.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token returns the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - resourceArn: The ARN of the resource.
    ///   - tags: The tags of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        clientToken: String? = TagResourceRequest.idempotencyToken(),
        resourceArn: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            clientToken: clientToken, 
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes one or more tags from the specified resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn+}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes one or more tags from the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The ARN of the resource.
    ///   - tagKeys: The list of tag keys to remove from the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates browser settings.
    @Sendable
    @inlinable
    public func updateBrowserSettings(_ input: UpdateBrowserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateBrowserSettingsResponse {
        try await self.client.execute(
            operation: "UpdateBrowserSettings", 
            path: "/browserSettings/{browserSettingsArn+}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates browser settings.
    ///
    /// Parameters:
    ///   - browserPolicy: A JSON string containing Chrome Enterprise policies that will be applied to all streaming sessions.
    ///   - browserSettingsArn: The ARN of the browser settings.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token return the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateBrowserSettings(
        browserPolicy: String? = nil,
        browserSettingsArn: String,
        clientToken: String? = UpdateBrowserSettingsRequest.idempotencyToken(),
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateBrowserSettingsResponse {
        let input = UpdateBrowserSettingsRequest(
            browserPolicy: browserPolicy, 
            browserSettingsArn: browserSettingsArn, 
            clientToken: clientToken
        )
        return try await self.updateBrowserSettings(input, logger: logger)
    }

    /// Updates data protection settings.
    @Sendable
    @inlinable
    public func updateDataProtectionSettings(_ input: UpdateDataProtectionSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDataProtectionSettingsResponse {
        try await self.client.execute(
            operation: "UpdateDataProtectionSettings", 
            path: "/dataProtectionSettings/{dataProtectionSettingsArn+}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates data protection settings.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token return the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - dataProtectionSettingsArn: The ARN of the data protection settings.
    ///   - description: The description of the data protection settings.
    ///   - displayName: The display name of the data protection settings.
    ///   - inlineRedactionConfiguration: The inline redaction configuration of the data protection settings that will be applied to all sessions.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDataProtectionSettings(
        clientToken: String? = UpdateDataProtectionSettingsRequest.idempotencyToken(),
        dataProtectionSettingsArn: String,
        description: String? = nil,
        displayName: String? = nil,
        inlineRedactionConfiguration: InlineRedactionConfiguration? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDataProtectionSettingsResponse {
        let input = UpdateDataProtectionSettingsRequest(
            clientToken: clientToken, 
            dataProtectionSettingsArn: dataProtectionSettingsArn, 
            description: description, 
            displayName: displayName, 
            inlineRedactionConfiguration: inlineRedactionConfiguration
        )
        return try await self.updateDataProtectionSettings(input, logger: logger)
    }

    /// Updates the identity provider.
    @Sendable
    @inlinable
    public func updateIdentityProvider(_ input: UpdateIdentityProviderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateIdentityProviderResponse {
        try await self.client.execute(
            operation: "UpdateIdentityProvider", 
            path: "/identityProviders/{identityProviderArn+}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the identity provider.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token return the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - identityProviderArn: The ARN of the identity provider.
    ///   - identityProviderDetails: The details of the identity provider. The following list describes the provider detail keys for each identity provider type.    For Google and Login with Amazon:    client_id     client_secret     authorize_scopes      For Facebook:    client_id     client_secret     authorize_scopes     api_version      For Sign in with Apple:    client_id     team_id     key_id     private_key     authorize_scopes      For OIDC providers:    client_id     client_secret     attributes_request_method     oidc_issuer     authorize_scopes     authorize_url if not available from discovery URL specified by oidc_issuer key     token_url if not available from discovery URL specified by oidc_issuer key     attributes_url if not available from discovery URL specified by oidc_issuer key     jwks_uri if not available from discovery URL specified by oidc_issuer key      For SAML providers:    MetadataFile OR MetadataURL     IDPSignout (boolean) optional     IDPInit (boolean) optional     RequestSigningAlgorithm (string) optional - Only accepts rsa-sha256     EncryptedResponses (boolean) optional
    ///   - identityProviderName: The name of the identity provider.
    ///   - identityProviderType: The type of the identity provider.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateIdentityProvider(
        clientToken: String? = UpdateIdentityProviderRequest.idempotencyToken(),
        identityProviderArn: String,
        identityProviderDetails: [String: String]? = nil,
        identityProviderName: String? = nil,
        identityProviderType: IdentityProviderType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateIdentityProviderResponse {
        let input = UpdateIdentityProviderRequest(
            clientToken: clientToken, 
            identityProviderArn: identityProviderArn, 
            identityProviderDetails: identityProviderDetails, 
            identityProviderName: identityProviderName, 
            identityProviderType: identityProviderType
        )
        return try await self.updateIdentityProvider(input, logger: logger)
    }

    /// Updates IP access settings.
    @Sendable
    @inlinable
    public func updateIpAccessSettings(_ input: UpdateIpAccessSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateIpAccessSettingsResponse {
        try await self.client.execute(
            operation: "UpdateIpAccessSettings", 
            path: "/ipAccessSettings/{ipAccessSettingsArn+}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates IP access settings.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token return the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - description: The description of the IP access settings.
    ///   - displayName: The display name of the IP access settings.
    ///   - ipAccessSettingsArn: The ARN of the IP access settings.
    ///   - ipRules: The updated IP rules of the IP access settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateIpAccessSettings(
        clientToken: String? = UpdateIpAccessSettingsRequest.idempotencyToken(),
        description: String? = nil,
        displayName: String? = nil,
        ipAccessSettingsArn: String,
        ipRules: [IpRule]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateIpAccessSettingsResponse {
        let input = UpdateIpAccessSettingsRequest(
            clientToken: clientToken, 
            description: description, 
            displayName: displayName, 
            ipAccessSettingsArn: ipAccessSettingsArn, 
            ipRules: ipRules
        )
        return try await self.updateIpAccessSettings(input, logger: logger)
    }

    /// Updates network settings.
    @Sendable
    @inlinable
    public func updateNetworkSettings(_ input: UpdateNetworkSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateNetworkSettingsResponse {
        try await self.client.execute(
            operation: "UpdateNetworkSettings", 
            path: "/networkSettings/{networkSettingsArn+}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates network settings.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token return the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - networkSettingsArn: The ARN of the network settings.
    ///   - securityGroupIds: One or more security groups used to control access from streaming instances to your VPC.
    ///   - subnetIds: The subnets in which network interfaces are created to connect streaming instances to your VPC. At least two of these subnets must be in different availability zones.
    ///   - vpcId: The VPC that streaming instances will connect to.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateNetworkSettings(
        clientToken: String? = UpdateNetworkSettingsRequest.idempotencyToken(),
        networkSettingsArn: String,
        securityGroupIds: [String]? = nil,
        subnetIds: [String]? = nil,
        vpcId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateNetworkSettingsResponse {
        let input = UpdateNetworkSettingsRequest(
            clientToken: clientToken, 
            networkSettingsArn: networkSettingsArn, 
            securityGroupIds: securityGroupIds, 
            subnetIds: subnetIds, 
            vpcId: vpcId
        )
        return try await self.updateNetworkSettings(input, logger: logger)
    }

    /// Updates a web portal.
    @Sendable
    @inlinable
    public func updatePortal(_ input: UpdatePortalRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePortalResponse {
        try await self.client.execute(
            operation: "UpdatePortal", 
            path: "/portals/{portalArn+}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a web portal.
    ///
    /// Parameters:
    ///   - authenticationType: The type of authentication integration points used when signing into the web portal. Defaults to Standard.  Standard web portals are authenticated directly through your identity provider. You need to call CreateIdentityProvider to integrate your identity provider with your web portal. User and group access to your web portal is controlled through your identity provider.  IAM Identity Center web portals are authenticated through IAM Identity Center. Identity sources (including external identity provider integration), plus user and group access to your web portal, can be configured in the IAM Identity Center.
    ///   - displayName: The name of the web portal. This is not visible to users who log into the web portal.
    ///   - instanceType: The type and resources of the underlying instance.
    ///   - maxConcurrentSessions: The maximum number of concurrent sessions for the portal.
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePortal(
        authenticationType: AuthenticationType? = nil,
        displayName: String? = nil,
        instanceType: InstanceType? = nil,
        maxConcurrentSessions: Int? = nil,
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePortalResponse {
        let input = UpdatePortalRequest(
            authenticationType: authenticationType, 
            displayName: displayName, 
            instanceType: instanceType, 
            maxConcurrentSessions: maxConcurrentSessions, 
            portalArn: portalArn
        )
        return try await self.updatePortal(input, logger: logger)
    }

    /// Updates the details of a session logger.
    @Sendable
    @inlinable
    public func updateSessionLogger(_ input: UpdateSessionLoggerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSessionLoggerResponse {
        try await self.client.execute(
            operation: "UpdateSessionLogger", 
            path: "/sessionLoggers/{sessionLoggerArn+}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the details of a session logger.
    ///
    /// Parameters:
    ///   - displayName: The updated display name.
    ///   - eventFilter: The updated eventFilter.
    ///   - logConfiguration: The updated logConfiguration.
    ///   - sessionLoggerArn: The ARN of the session logger to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSessionLogger(
        displayName: String? = nil,
        eventFilter: EventFilter? = nil,
        logConfiguration: LogConfiguration? = nil,
        sessionLoggerArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSessionLoggerResponse {
        let input = UpdateSessionLoggerRequest(
            displayName: displayName, 
            eventFilter: eventFilter, 
            logConfiguration: logConfiguration, 
            sessionLoggerArn: sessionLoggerArn
        )
        return try await self.updateSessionLogger(input, logger: logger)
    }

    /// Updates the trust store.
    @Sendable
    @inlinable
    public func updateTrustStore(_ input: UpdateTrustStoreRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateTrustStoreResponse {
        try await self.client.execute(
            operation: "UpdateTrustStore", 
            path: "/trustStores/{trustStoreArn+}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the trust store.
    ///
    /// Parameters:
    ///   - certificatesToAdd: A list of CA certificates to add to the trust store.
    ///   - certificatesToDelete: A list of CA certificates to delete from a trust store.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token return the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - trustStoreArn: The ARN of the trust store.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateTrustStore(
        certificatesToAdd: [AWSBase64Data]? = nil,
        certificatesToDelete: [String]? = nil,
        clientToken: String? = UpdateTrustStoreRequest.idempotencyToken(),
        trustStoreArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateTrustStoreResponse {
        let input = UpdateTrustStoreRequest(
            certificatesToAdd: certificatesToAdd, 
            certificatesToDelete: certificatesToDelete, 
            clientToken: clientToken, 
            trustStoreArn: trustStoreArn
        )
        return try await self.updateTrustStore(input, logger: logger)
    }

    /// Updates the user access logging settings.
    @Sendable
    @inlinable
    public func updateUserAccessLoggingSettings(_ input: UpdateUserAccessLoggingSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateUserAccessLoggingSettingsResponse {
        try await self.client.execute(
            operation: "UpdateUserAccessLoggingSettings", 
            path: "/userAccessLoggingSettings/{userAccessLoggingSettingsArn+}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the user access logging settings.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token return the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - kinesisStreamArn: The ARN of the Kinesis stream.
    ///   - userAccessLoggingSettingsArn: The ARN of the user access logging settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUserAccessLoggingSettings(
        clientToken: String? = UpdateUserAccessLoggingSettingsRequest.idempotencyToken(),
        kinesisStreamArn: String? = nil,
        userAccessLoggingSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateUserAccessLoggingSettingsResponse {
        let input = UpdateUserAccessLoggingSettingsRequest(
            clientToken: clientToken, 
            kinesisStreamArn: kinesisStreamArn, 
            userAccessLoggingSettingsArn: userAccessLoggingSettingsArn
        )
        return try await self.updateUserAccessLoggingSettings(input, logger: logger)
    }

    /// Updates the user settings.
    @Sendable
    @inlinable
    public func updateUserSettings(_ input: UpdateUserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateUserSettingsResponse {
        try await self.client.execute(
            operation: "UpdateUserSettings", 
            path: "/userSettings/{userSettingsArn+}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the user settings.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully, subsequent retries with the same client token return the result from the original successful request.  If you do not specify a client token, one is automatically generated by the Amazon Web Services SDK.
    ///   - cookieSynchronizationConfiguration: The configuration that specifies which cookies should be synchronized from the end user's local browser to the remote browser. If the allowlist and blocklist are empty, the configuration becomes null.
    ///   - copyAllowed: Specifies whether the user can copy text from the streaming session to the local device.
    ///   - deepLinkAllowed: Specifies whether the user can use deep links that open automatically when connecting to a session.
    ///   - disconnectTimeoutInMinutes: The amount of time that a streaming session remains active after users disconnect.
    ///   - downloadAllowed: Specifies whether the user can download files from the streaming session to the local device.
    ///   - idleDisconnectTimeoutInMinutes: The amount of time that users can be idle (inactive) before they are disconnected from their streaming session and the disconnect timeout interval begins.
    ///   - pasteAllowed: Specifies whether the user can paste text from the local device to the streaming session.
    ///   - printAllowed: Specifies whether the user can print to the local device.
    ///   - toolbarConfiguration: The configuration of the toolbar. This allows administrators to select the toolbar type and visual mode, set maximum display resolution for sessions, and choose which items are visible to end users during their sessions. If administrators do not modify these settings, end users retain control over their toolbar preferences.
    ///   - uploadAllowed: Specifies whether the user can upload files from the local device to the streaming session.
    ///   - userSettingsArn: The ARN of the user settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUserSettings(
        clientToken: String? = UpdateUserSettingsRequest.idempotencyToken(),
        cookieSynchronizationConfiguration: CookieSynchronizationConfiguration? = nil,
        copyAllowed: EnabledType? = nil,
        deepLinkAllowed: EnabledType? = nil,
        disconnectTimeoutInMinutes: Int? = nil,
        downloadAllowed: EnabledType? = nil,
        idleDisconnectTimeoutInMinutes: Int? = nil,
        pasteAllowed: EnabledType? = nil,
        printAllowed: EnabledType? = nil,
        toolbarConfiguration: ToolbarConfiguration? = nil,
        uploadAllowed: EnabledType? = nil,
        userSettingsArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateUserSettingsResponse {
        let input = UpdateUserSettingsRequest(
            clientToken: clientToken, 
            cookieSynchronizationConfiguration: cookieSynchronizationConfiguration, 
            copyAllowed: copyAllowed, 
            deepLinkAllowed: deepLinkAllowed, 
            disconnectTimeoutInMinutes: disconnectTimeoutInMinutes, 
            downloadAllowed: downloadAllowed, 
            idleDisconnectTimeoutInMinutes: idleDisconnectTimeoutInMinutes, 
            pasteAllowed: pasteAllowed, 
            printAllowed: printAllowed, 
            toolbarConfiguration: toolbarConfiguration, 
            uploadAllowed: uploadAllowed, 
            userSettingsArn: userSettingsArn
        )
        return try await self.updateUserSettings(input, logger: logger)
    }
}

extension WorkSpacesWeb {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: WorkSpacesWeb, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension WorkSpacesWeb {
    /// Return PaginatorSequence for operation ``listBrowserSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listBrowserSettingsPaginator(
        _ input: ListBrowserSettingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListBrowserSettingsRequest, ListBrowserSettingsResponse> {
        return .init(
            input: input,
            command: self.listBrowserSettings,
            inputKey: \ListBrowserSettingsRequest.nextToken,
            outputKey: \ListBrowserSettingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listBrowserSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listBrowserSettingsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListBrowserSettingsRequest, ListBrowserSettingsResponse> {
        let input = ListBrowserSettingsRequest(
            maxResults: maxResults
        )
        return self.listBrowserSettingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDataProtectionSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataProtectionSettingsPaginator(
        _ input: ListDataProtectionSettingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDataProtectionSettingsRequest, ListDataProtectionSettingsResponse> {
        return .init(
            input: input,
            command: self.listDataProtectionSettings,
            inputKey: \ListDataProtectionSettingsRequest.nextToken,
            outputKey: \ListDataProtectionSettingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDataProtectionSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDataProtectionSettingsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDataProtectionSettingsRequest, ListDataProtectionSettingsResponse> {
        let input = ListDataProtectionSettingsRequest(
            maxResults: maxResults
        )
        return self.listDataProtectionSettingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listIdentityProviders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listIdentityProvidersPaginator(
        _ input: ListIdentityProvidersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListIdentityProvidersRequest, ListIdentityProvidersResponse> {
        return .init(
            input: input,
            command: self.listIdentityProviders,
            inputKey: \ListIdentityProvidersRequest.nextToken,
            outputKey: \ListIdentityProvidersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listIdentityProviders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - portalArn: The ARN of the web portal.
    ///   - logger: Logger used for logging
    @inlinable
    public func listIdentityProvidersPaginator(
        maxResults: Int? = nil,
        portalArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListIdentityProvidersRequest, ListIdentityProvidersResponse> {
        let input = ListIdentityProvidersRequest(
            maxResults: maxResults, 
            portalArn: portalArn
        )
        return self.listIdentityProvidersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listIpAccessSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listIpAccessSettingsPaginator(
        _ input: ListIpAccessSettingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListIpAccessSettingsRequest, ListIpAccessSettingsResponse> {
        return .init(
            input: input,
            command: self.listIpAccessSettings,
            inputKey: \ListIpAccessSettingsRequest.nextToken,
            outputKey: \ListIpAccessSettingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listIpAccessSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listIpAccessSettingsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListIpAccessSettingsRequest, ListIpAccessSettingsResponse> {
        let input = ListIpAccessSettingsRequest(
            maxResults: maxResults
        )
        return self.listIpAccessSettingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listNetworkSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listNetworkSettingsPaginator(
        _ input: ListNetworkSettingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListNetworkSettingsRequest, ListNetworkSettingsResponse> {
        return .init(
            input: input,
            command: self.listNetworkSettings,
            inputKey: \ListNetworkSettingsRequest.nextToken,
            outputKey: \ListNetworkSettingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listNetworkSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listNetworkSettingsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListNetworkSettingsRequest, ListNetworkSettingsResponse> {
        let input = ListNetworkSettingsRequest(
            maxResults: maxResults
        )
        return self.listNetworkSettingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPortals(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPortalsPaginator(
        _ input: ListPortalsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPortalsRequest, ListPortalsResponse> {
        return .init(
            input: input,
            command: self.listPortals,
            inputKey: \ListPortalsRequest.nextToken,
            outputKey: \ListPortalsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPortals(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPortalsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPortalsRequest, ListPortalsResponse> {
        let input = ListPortalsRequest(
            maxResults: maxResults
        )
        return self.listPortalsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSessionLoggers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSessionLoggersPaginator(
        _ input: ListSessionLoggersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSessionLoggersRequest, ListSessionLoggersResponse> {
        return .init(
            input: input,
            command: self.listSessionLoggers,
            inputKey: \ListSessionLoggersRequest.nextToken,
            outputKey: \ListSessionLoggersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSessionLoggers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSessionLoggersPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSessionLoggersRequest, ListSessionLoggersResponse> {
        let input = ListSessionLoggersRequest(
            maxResults: maxResults
        )
        return self.listSessionLoggersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSessions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSessionsPaginator(
        _ input: ListSessionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSessionsRequest, ListSessionsResponse> {
        return .init(
            input: input,
            command: self.listSessions,
            inputKey: \ListSessionsRequest.nextToken,
            outputKey: \ListSessionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSessions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - portalId: The ID of the web portal for the sessions.
    ///   - sessionId: The ID of the session.
    ///   - sortBy: The method in which the returned sessions should be sorted.
    ///   - status: The status of the session.
    ///   - username: The username of the session.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSessionsPaginator(
        maxResults: Int? = nil,
        portalId: String,
        sessionId: String? = nil,
        sortBy: SessionSortBy? = nil,
        status: SessionStatus? = nil,
        username: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSessionsRequest, ListSessionsResponse> {
        let input = ListSessionsRequest(
            maxResults: maxResults, 
            portalId: portalId, 
            sessionId: sessionId, 
            sortBy: sortBy, 
            status: status, 
            username: username
        )
        return self.listSessionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTrustStoreCertificates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTrustStoreCertificatesPaginator(
        _ input: ListTrustStoreCertificatesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTrustStoreCertificatesRequest, ListTrustStoreCertificatesResponse> {
        return .init(
            input: input,
            command: self.listTrustStoreCertificates,
            inputKey: \ListTrustStoreCertificatesRequest.nextToken,
            outputKey: \ListTrustStoreCertificatesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTrustStoreCertificates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - trustStoreArn: The ARN of the trust store
    ///   - logger: Logger used for logging
    @inlinable
    public func listTrustStoreCertificatesPaginator(
        maxResults: Int? = nil,
        trustStoreArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTrustStoreCertificatesRequest, ListTrustStoreCertificatesResponse> {
        let input = ListTrustStoreCertificatesRequest(
            maxResults: maxResults, 
            trustStoreArn: trustStoreArn
        )
        return self.listTrustStoreCertificatesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTrustStores(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTrustStoresPaginator(
        _ input: ListTrustStoresRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTrustStoresRequest, ListTrustStoresResponse> {
        return .init(
            input: input,
            command: self.listTrustStores,
            inputKey: \ListTrustStoresRequest.nextToken,
            outputKey: \ListTrustStoresResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTrustStores(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTrustStoresPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTrustStoresRequest, ListTrustStoresResponse> {
        let input = ListTrustStoresRequest(
            maxResults: maxResults
        )
        return self.listTrustStoresPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listUserAccessLoggingSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listUserAccessLoggingSettingsPaginator(
        _ input: ListUserAccessLoggingSettingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListUserAccessLoggingSettingsRequest, ListUserAccessLoggingSettingsResponse> {
        return .init(
            input: input,
            command: self.listUserAccessLoggingSettings,
            inputKey: \ListUserAccessLoggingSettingsRequest.nextToken,
            outputKey: \ListUserAccessLoggingSettingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listUserAccessLoggingSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listUserAccessLoggingSettingsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListUserAccessLoggingSettingsRequest, ListUserAccessLoggingSettingsResponse> {
        let input = ListUserAccessLoggingSettingsRequest(
            maxResults: maxResults
        )
        return self.listUserAccessLoggingSettingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listUserSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listUserSettingsPaginator(
        _ input: ListUserSettingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListUserSettingsRequest, ListUserSettingsResponse> {
        return .init(
            input: input,
            command: self.listUserSettings,
            inputKey: \ListUserSettingsRequest.nextToken,
            outputKey: \ListUserSettingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listUserSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be included in the next page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listUserSettingsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListUserSettingsRequest, ListUserSettingsResponse> {
        let input = ListUserSettingsRequest(
            maxResults: maxResults
        )
        return self.listUserSettingsPaginator(input, logger: logger)
    }
}

extension WorkSpacesWeb.ListBrowserSettingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkSpacesWeb.ListBrowserSettingsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension WorkSpacesWeb.ListDataProtectionSettingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkSpacesWeb.ListDataProtectionSettingsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension WorkSpacesWeb.ListIdentityProvidersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkSpacesWeb.ListIdentityProvidersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            portalArn: self.portalArn
        )
    }
}

extension WorkSpacesWeb.ListIpAccessSettingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkSpacesWeb.ListIpAccessSettingsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension WorkSpacesWeb.ListNetworkSettingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkSpacesWeb.ListNetworkSettingsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension WorkSpacesWeb.ListPortalsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkSpacesWeb.ListPortalsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension WorkSpacesWeb.ListSessionLoggersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkSpacesWeb.ListSessionLoggersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension WorkSpacesWeb.ListSessionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkSpacesWeb.ListSessionsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            portalId: self.portalId,
            sessionId: self.sessionId,
            sortBy: self.sortBy,
            status: self.status,
            username: self.username
        )
    }
}

extension WorkSpacesWeb.ListTrustStoreCertificatesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkSpacesWeb.ListTrustStoreCertificatesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            trustStoreArn: self.trustStoreArn
        )
    }
}

extension WorkSpacesWeb.ListTrustStoresRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkSpacesWeb.ListTrustStoresRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension WorkSpacesWeb.ListUserAccessLoggingSettingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkSpacesWeb.ListUserAccessLoggingSettingsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension WorkSpacesWeb.ListUserSettingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> WorkSpacesWeb.ListUserSettingsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}
